Python Asyncio ಅನ್ನು ಹೇಗೆ ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು: ಟಾಸ್ಕ್ ರಚನೆ ಮತ್ತು ನಿರ್ವಹಣೆಯ ಬಗ್ಗೆ ಆಳವಾದ ವಿಮರ್ಶೆ

ಆಧುನಿಕ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ಜಗತ್ತಿನಲ್ಲಿ, ಕಾರ್ಯಕ್ಷಮತೆ ಅತ್ಯುನ್ನತವಾಗಿದೆ. ಸಾವಿರಾರು ಸಮಕಾಲಿಕ ನೆಟ್‌ವರ್ಕ್ ಸಂಪರ್ಕಗಳು, ಡೇಟಾಬೇಸ್ ಪ್ರಶ್ನೆಗಳು ಮತ್ತು API ಕರೆಗಳನ್ನು ಯಾವುದೇ ತೊಂದರೆಗಳಿಲ್ಲದೆ ನಿರ್ವಹಿಸುವ, ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ. I/O-ಬೌಂಡ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ—ಪ್ರೋಗ್ರಾಂ ನೆಟ್‌ವರ್ಕ್ ಅಥವಾ ಡಿಸ್ಕ್‌ನಂತಹ ಬಾಹ್ಯ ಸಂಪನ್ಮೂಲಗಳಿಗಾಗಿ ಕಾಯುವುದರಲ್ಲಿ ಹೆಚ್ಚಿನ ಸಮಯವನ್ನು ಕಳೆಯುತ್ತದೆ—ಸಾಂಪ್ರದಾಯಿಕ ಸಿಂಕ್ರೊನಸ್ ಕೋಡ್ ಗಮನಾರ್ಹವಾದ ಅಡಚಣೆಯಾಗಬಹುದು. ಇಲ್ಲಿಯೇ ಅಸಮಕಾಲಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಿಂಚುತ್ತದೆ ಮತ್ತು ಈ ಶಕ್ತಿಯನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಲು Python ನ asyncio ಲೈಬ್ರರಿ ಪ್ರಮುಖವಾಗಿದೆ.

asyncio ನ ಸಮಕಾಲೀನ ಮಾದರಿಯ ಹೃದಯಭಾಗದಲ್ಲಿ ಸರಳವಾದ ಆದರೆ ಶಕ್ತಿಯುತವಾದ ಪರಿಕಲ್ಪನೆ ಇದೆ: ಕಾರ್ಯ. ಕೊರೂಟಿನ್‌ಗಳು ಏನು ಮಾಡಬೇಕೆಂದು ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ, ಕಾರ್ಯಗಳು ನಿಜವಾಗಿ ಕೆಲಸವನ್ನು ಪೂರ್ಣಗೊಳಿಸುತ್ತವೆ. ಇವು ಸಮಕಾಲಿಕ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಮೂಲ ಘಟಕವಾಗಿದೆ, ಇದು ನಿಮ್ಮ Python ಪ್ರೋಗ್ರಾಂಗಳು ಅನೇಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ನಿರ್ವಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಇದು ಥ್ರೋಪುಟ್ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ.

ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ ನಿಮ್ಮನ್ನು asyncio.Taskಗೆ ಆಳವಾಗಿ ಕರೆದೊಯ್ಯುತ್ತದೆ. ರಚನೆಯ ಮೂಲಭೂತ ಅಂಶಗಳಿಂದ ಹಿಡಿದು ಸುಧಾರಿತ ನಿರ್ವಹಣಾ ಮಾದರಿಗಳು, ರದ್ದತಿ ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳವರೆಗೆ ಎಲ್ಲವನ್ನೂ ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ನೀವು ಹೆಚ್ಚಿನ ದಟ್ಟಣೆಯ ವೆಬ್ ಸೇವೆಯನ್ನು, ಡೇಟಾ ಸ್ಕ್ರೇಪಿಂಗ್ ಉಪಕರಣವನ್ನು ಅಥವಾ ನೈಜ-ಸಮಯದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿರಲಿ, ಕಾರ್ಯಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು ಯಾವುದೇ ಆಧುನಿಕ Python ಡೆವಲಪರ್‌ಗೆ ಅತ್ಯಗತ್ಯ ಕೌಶಲ್ಯವಾಗಿದೆ.

ಕೊರೂಟಿನ್ ಎಂದರೇನು? ತ್ವರಿತ ರಿಫ್ರೆಶರ್

ನಾವು ಚಲಿಸುವ ಮೊದಲು, ನಾವು ನಡೆಯಬೇಕು. ಮತ್ತು asyncio ಜಗತ್ತಿನಲ್ಲಿ, ನಡಿಗೆಯು ಕೊರೂಟಿನ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು. ಕೊರೂಟಿನ್ ಎಂದರೆ async def ನೊಂದಿಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಒಂದು ವಿಶೇಷ ರೀತಿಯ ಕಾರ್ಯವಾಗಿದೆ.

ನೀವು ಸಾಮಾನ್ಯ Python ಕಾರ್ಯವನ್ನು ಕರೆದಾಗ, ಅದು ಪ್ರಾರಂಭದಿಂದ ಕೊನೆಯವರೆಗೆ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ. ನೀವು ಕೊರೂಟಿನ್ ಕಾರ್ಯವನ್ನು ಕರೆದಾಗ, ಅದು ತಕ್ಷಣವೇ ಕಾರ್ಯಗತವಾಗುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ಇದು ಕೊರೂಟಿನ್ ವಸ್ತು ವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಈ ವಸ್ತುವನ್ನು ಮಾಡಬೇಕಾದ ಕೆಲಸಕ್ಕಾಗಿ ನೀಲನಕ್ಷೆ ಎಂದು ಪರಿಗಣಿಸಬಹುದು, ಆದರೆ ಇದು ತನ್ನದೇ ಆದ ಮೇಲೆ ಜಡವಾಗಿರುತ್ತದೆ. ಇದು ಅಮಾನತುಗೊಳಿಸಬಹುದಾದ, ಪ್ರಾರಂಭಿಸಬಹುದಾದ ಮತ್ತು ಪುನರಾರಂಭಿಸಬಹುದಾದ ವಿರಾಮಗೊಳಿಸಿದ ಲೆಕ್ಕಾಚಾರವಾಗಿದೆ.

            import asyncio

async def say_hello(name: str):
    print(f"Preparing to greet {name}...")
    await asyncio.sleep(1)  # Simulate a non-blocking I/O operation
    print(f"Hello, {name}!")

# Calling the function doesn't run it, it creates a coroutine object
coro = say_hello("World")
print(f"Created a coroutine object: {coro}")

# To actually run it, you need to use an entry point like asyncio.run()
# asyncio.run(coro)
            

              
                Copy
              
            
          

ಮ್ಯಾಜಿಕ್ ಕೀವರ್ಡ್ await ಆಗಿದೆ. ಇದು ಈವೆಂಟ್ ಲೂಪ್‌ಗೆ ಹೇಳುತ್ತದೆ, "ಈ ಕಾರ್ಯಾಚರಣೆಗೆ ಸ್ವಲ್ಪ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಆದ್ದರಿಂದ ಇಲ್ಲಿ ನನ್ನನ್ನು ವಿರಾಮಗೊಳಿಸಿ ಮತ್ತು ಬೇರೆ ಯಾವುದನ್ನಾದರೂ ಕೆಲಸ ಮಾಡಿ. ಈ ಕಾರ್ಯಾಚರಣೆ ಪೂರ್ಣಗೊಂಡಾಗ ನನ್ನನ್ನು ಎಚ್ಚರಗೊಳಿಸಿ." ವಿರಾಮಗೊಳಿಸುವ ಮತ್ತು ಸಂದರ್ಭಗಳನ್ನು ಬದಲಾಯಿಸುವ ಈ ಸಾಮರ್ಥ್ಯವು ಸಮಕಾಲೀನತೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.

ಸಮಕಾಲೀನತೆಯ ಹೃದಯ: asyncio.Task ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಆದ್ದರಿಂದ, ಕೊರೂಟಿನ್ ಒಂದು ನೀಲನಕ್ಷೆಯಾಗಿದೆ. ಅಡುಗೆಮನೆಯನ್ನು (ಈವೆಂಟ್ ಲೂಪ್) ಅಡುಗೆ ಮಾಡಲು ಹೇಗೆ ಹೇಳುವುದು? ಇಲ್ಲಿಯೇ asyncio.Task ಬರುತ್ತದೆ.

ಒಂದು asyncio.Task ಎಂಬುದು ಕೊರೂಟಿನ್ ಅನ್ನು ಸುತ್ತುವರಿಯುವ ಮತ್ತು ಅದನ್ನು asyncio ಈವೆಂಟ್ ಲೂಪ್‌ನಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿಗದಿಪಡಿಸುವ ಒಂದು ವಸ್ತುವಾಗಿದೆ. ಇದನ್ನು ಈ ರೀತಿ ಯೋಚಿಸಿ:

• ಕೊರೂಟಿನ್ (async def): ಒಂದು ಖಾದ್ಯಕ್ಕಾಗಿ ವಿವರವಾದ ಪಾಕವಿಧಾನ.
• ಈವೆಂಟ್ ಲೂಪ್: ಎಲ್ಲಾ ಅಡುಗೆ ನಡೆಯುವ ಕೇಂದ್ರ ಅಡುಗೆಮನೆ.
• await my_coro(): ನೀವು ಅಡುಗೆಮನೆಯಲ್ಲಿ ನಿಂತು ಪಾಕವಿಧಾನವನ್ನು ಹಂತ-ಹಂತವಾಗಿ ನೀವೇ ಅನುಸರಿಸುತ್ತೀರಿ. ಖಾದ್ಯ ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ನೀವು ಬೇರೆ ಏನನ್ನೂ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ಇದು ಅನುಕ್ರಮ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ.
• asyncio.create_task(my_coro()): ನೀವು ಪಾಕವಿಧಾನವನ್ನು ಅಡುಗೆಮನೆಯಲ್ಲಿನ ಬಾಣಸಿಗನಿಗೆ (ಕಾರ್ಯ) ನೀಡುತ್ತೀರಿ ಮತ್ತು ಹೇಳುತ್ತೀರಿ, "ಇದರ ಮೇಲೆ ಕೆಲಸ ಪ್ರಾರಂಭಿಸಿ." ಬಾಣಸಿಗ ತಕ್ಷಣವೇ ಪ್ರಾರಂಭಿಸುತ್ತಾನೆ ಮತ್ತು ನೀವು ಹೆಚ್ಚಿನ ಪಾಕವಿಧಾನಗಳನ್ನು ನೀಡುವಂತೆ ಇತರ ಕೆಲಸಗಳನ್ನು ಮಾಡಲು ಮುಕ್ತರಾಗುತ್ತೀರಿ. ಇದು ಸಮಕಾಲೀನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ.

ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸವೆಂದರೆ asyncio.create_task() ಕೊರೂಟಿನ್ ಅನ್ನು "ಹಿನ್ನೆಲೆಯಲ್ಲಿ" ಚಲಾಯಿಸಲು ನಿಗದಿಪಡಿಸುತ್ತದೆ ಮತ್ತು ತಕ್ಷಣವೇ ನಿಮ್ಮ ಕೋಡ್‌ಗೆ ನಿಯಂತ್ರಣವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ನೀವು Task ವಸ್ತುವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೀರಿ, ಇದು ಈ ನಡೆಯುತ್ತಿರುವ ಕಾರ್ಯಾಚರಣೆಗೆ ಹ್ಯಾಂಡಲ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಅದರ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಲು, ಅದನ್ನು ರದ್ದುಗೊಳಿಸಲು ಅಥವಾ ಅದರ ಫಲಿತಾಂಶಕ್ಕಾಗಿ ನಂತರ ಕಾಯಲು ನೀವು ಈ ಹ್ಯಾಂಡಲ್ ಅನ್ನು ಬಳಸಬಹುದು.

ನಿಮ್ಮ ಮೊದಲ ಕಾರ್ಯಗಳನ್ನು ರಚಿಸುವುದು: `asyncio.create_task()` ಕಾರ್ಯ

ಕಾರ್ಯವನ್ನು ರಚಿಸುವ ಮುಖ್ಯ ಮಾರ್ಗವೆಂದರೆ asyncio.create_task() ಕಾರ್ಯ. ಇದು ತನ್ನ ವಾದವಾಗಿ ಕೊರೂಟಿನ್ ವಸ್ತುವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿಗದಿಪಡಿಸುತ್ತದೆ.

ಮೂಲ ಸಿಂಟ್ಯಾಕ್ಸ್

ಬಳಕೆಯು ನೇರವಾಗಿರುತ್ತದೆ:

            import asyncio

async def my_background_work():
    print("Starting background work...")
    await asyncio.sleep(2)
    print("Background work finished.")
    return "Success"

async def main():
    print("Main function started.")
    # Schedule my_background_work to run concurrently
    task = asyncio.create_task(my_background_work())
    
    # While the task runs, we can do other things
    print("Task created. Main function continues to run.")
    await asyncio.sleep(1)
    print("Main function did some other work.")

    # Now, wait for the task to complete and get its result
    result = await task
    print(f"Task completed with result: {result}")

asyncio.run(main())
            

              
                Copy
              
            
          

ಔಟ್‌ಪುಟ್ ಕಾರ್ಯವನ್ನು ರಚಿಸಿದ ತಕ್ಷಣ `main` ಕಾರ್ಯವು ಅದರ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಹೇಗೆ ಮುಂದುವರಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಇದು ಬ್ಲಾಕ್ ಆಗುವುದಿಲ್ಲ. ನಾವು ಕೊನೆಯಲ್ಲಿ ಸ್ಪಷ್ಟವಾಗಿ `await task` ಮಾಡಿದಾಗ ಮಾತ್ರ ಇದು ವಿರಾಮಗೊಳಿಸುತ್ತದೆ.

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ: ಸಮಕಾಲೀನ ವೆಬ್ ವಿನಂತಿಗಳು

ಸಾಮಾನ್ಯ ಸನ್ನಿವೇಶದೊಂದಿಗೆ ಕಾರ್ಯಗಳ ನಿಜವಾದ ಶಕ್ತಿಯನ್ನು ನೋಡೋಣ: ಅನೇಕ URL ಗಳಿಂದ ಡೇಟಾವನ್ನು ತರುವುದು. ಇದಕ್ಕಾಗಿ, ನಾವು ಜನಪ್ರಿಯ `aiohttp` ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದನ್ನು ನೀವು `pip install aiohttp` ನೊಂದಿಗೆ ಸ್ಥಾಪಿಸಬಹುದು.

ಮೊದಲಿಗೆ, ಅನುಕ್ರಮ (ನಿಧಾನ) ಮಾರ್ಗವನ್ನು ನೋಡೋಣ:

            import asyncio
import aiohttp
import time

async def fetch_status(session, url):
    async with session.get(url) as response:
        return response.status

async def main_sequential():
    urls = [
        "https://www.python.org",
        "https://www.google.com",
        "https://www.github.com",
        "https://www.microsoft.com"
    ]
    start_time = time.time()
    async with aiohttp.ClientSession() as session:
        for url in urls:
            status = await fetch_status(session, url)
            print(f"Status for {url}: {status}")
    end_time = time.time()
    print(f"Sequential execution took {end_time - start_time:.2f} seconds")

# To run this, you would use: asyncio.run(main_sequential())
            

              
                Copy
              
            
          

ಪ್ರತಿ ವಿನಂತಿಯು ಸುಮಾರು 0.5 ಸೆಕೆಂಡುಗಳನ್ನು ತೆಗೆದುಕೊಂಡರೆ, ಒಟ್ಟು ಸಮಯ ಸುಮಾರು 2 ಸೆಕೆಂಡುಗಳು ಇರುತ್ತದೆ, ಏಕೆಂದರೆ ಪ್ರತಿ `await` ಆ ಒಂದು ವಿನಂತಿಯು ಮುಗಿಯುವವರೆಗೆ ಲೂಪ್ ಅನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ.

ಈಗ, ಕಾರ್ಯಗಳೊಂದಿಗೆ ಸಮಕಾಲೀನತೆಯ ಶಕ್ತಿಯನ್ನು ಬಿಡುಗಡೆ ಮಾಡೋಣ:

            import asyncio
import aiohttp
import time

# fetch_status coroutine remains the same
async def fetch_status(session, url):
    async with session.get(url) as response:
        return response.status

async def main_concurrent():
    urls = [
        "https://www.python.org",
        "https://www.google.com",
        "https://www.github.com",
        "https://www.microsoft.com"
    ]
    start_time = time.time()
    async with aiohttp.ClientSession() as session:
        # Create a list of tasks, but don't await them yet
        tasks = [asyncio.create_task(fetch_status(session, url)) for url in urls]
        
        # Now, wait for all tasks to complete
        statuses = await asyncio.gather(*tasks)
        
        for url, status in zip(urls, statuses):
            print(f"Status for {url}: {status}")
            
    end_time = time.time()
    print(f"Concurrent execution took {end_time - start_time:.2f} seconds")

asyncio.run(main_concurrent())

            

              
                Copy
              
            
          

ನೀವು ಸಮಕಾಲೀನ ಆವೃತ್ತಿಯನ್ನು ಚಲಾಯಿಸಿದಾಗ, ನೀವು ನಾಟಕೀಯ ವ್ಯತ್ಯಾಸವನ್ನು ನೋಡುತ್ತೀರಿ. ಒಟ್ಟು ಸಮಯವು ಸುಮಾರು ದೀರ್ಘವಾದ ಒಂದೇ ವಿನಂತಿಯ ಸಮಯವಾಗಿರುತ್ತದೆ, ಎಲ್ಲರ ಮೊತ್ತವಲ್ಲ. ಏಕೆಂದರೆ ಮೊದಲ `fetch_status` ಕೊರೂಟಿನ್ ಅದರ `await session.get(url)` ಅನ್ನು ಹೊಡೆದ ತಕ್ಷಣ, ಈವೆಂಟ್ ಲೂಪ್ ಅದನ್ನು ವಿರಾಮಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ತಕ್ಷಣವೇ ಮುಂದಿನದನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಎಲ್ಲಾ ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿಗಳು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಒಂದೇ ಸಮಯದಲ್ಲಿ ನಡೆಯುತ್ತವೆ.

ಕಾರ್ಯಗಳ ಗುಂಪನ್ನು ನಿರ್ವಹಿಸುವುದು: ಅಗತ್ಯ ಮಾದರಿಗಳು

ಪ್ರತ್ಯೇಕ ಕಾರ್ಯಗಳನ್ನು ರಚಿಸುವುದು ಉತ್ತಮ, ಆದರೆ ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ, ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಅವುಗಳ ಸಂಪೂರ್ಣ ಗುಂಪನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕು, ನಿರ್ವಹಿಸಬೇಕು ಮತ್ತು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. `asyncio` ಇದಕ್ಕಾಗಿ ಹಲವಾರು ಶಕ್ತಿಯುತ ಪರಿಕರಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಆಧುನಿಕ ವಿಧಾನ (Python 3.11+): `asyncio.TaskGroup`

Python 3.11 ರಲ್ಲಿ ಪರಿಚಯಿಸಲ್ಪಟ್ಟಿದೆ, `TaskGroup` ಸಂಬಂಧಿತ ಕಾರ್ಯಗಳ ಗುಂಪನ್ನು ನಿರ್ವಹಿಸಲು ಹೊಸ, ಶಿಫಾರಸು ಮಾಡಲಾದ ಮತ್ತು ಸುರಕ್ಷಿತ ಮಾರ್ಗವಾಗಿದೆ. ಇದು ರಚನಾತ್ಮಕ ಸಮಕಾಲೀನತೆ ಎಂದು ಕರೆಯಲ್ಪಡುವದನ್ನು ಒದಗಿಸುತ್ತದೆ.

`TaskGroup` ನ ಪ್ರಮುಖ ಲಕ್ಷಣಗಳು:

• ಖಾತರಿಪಡಿಸಿದ ಸ್ವಚ್ಛಗೊಳಿಸುವಿಕೆ: ಅದರಲ್ಲಿ ರಚಿಸಲಾದ ಎಲ್ಲಾ ಕಾರ್ಯಗಳು ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ `async with` ಬ್ಲಾಕ್ ನಿರ್ಗಮಿಸುವುದಿಲ್ಲ.
• ದೃಢವಾದ ದೋಷ ನಿರ್ವಹಣೆ: ಗುಂಪಿನಲ್ಲಿ ಯಾವುದೇ ಕಾರ್ಯವು ವಿನಾಯಿತಿಯನ್ನು ಎತ್ತಿದರೆ, ಗುಂಪಿನಲ್ಲಿರುವ ಎಲ್ಲಾ ಇತರ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರದ್ದುಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ವಿನಾಯಿತಿಯನ್ನು (ಅಥವಾ `ExceptionGroup`) `async with` ಬ್ಲಾಕ್‌ನಿಂದ ನಿರ್ಗಮಿಸುವಾಗ ಮತ್ತೆ ಎತ್ತಲಾಗುತ್ತದೆ. ಇದು ಅನಾಥ ಕಾರ್ಯಗಳನ್ನು ತಡೆಯುತ್ತದೆ ಮತ್ತು ಊಹಿಸಬಹುದಾದ ಸ್ಥಿತಿಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಇದನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದು ಇಲ್ಲಿದೆ:

            import asyncio

async def worker(delay):
    print(f"Worker starting, will sleep for {delay}s")
    await asyncio.sleep(delay)
    # This worker will fail
    if delay == 2:
        raise ValueError("Something went wrong in worker 2")
    print(f"Worker with delay {delay} finished")
    return f"Result from {delay}s"

async def main():
    print("Starting main with TaskGroup...")
    try:
        async with asyncio.TaskGroup() as tg:
            task1 = tg.create_task(worker(1))
            task2 = tg.create_task(worker(2)) # This one will fail
            task3 = tg.create_task(worker(3))
            
            print("Tasks created in the group.")
        
        # This part of the code will NOT be reached if an exception occurs
        # The results would be accessed via task1.result(), etc.
        print("All tasks completed successfully.")

    except* ValueError as eg: # Note the `except*` for ExceptionGroup
        print(f"Caught an exception group with {len(eg.exceptions)} exceptions.")
        for exc in eg.exceptions:
            print(f" - {exc}")
    
    print("Main function finished.")

asyncio.run(main())
            

              
                Copy
              
            
          

ನೀವು ಇದನ್ನು ಚಲಾಯಿಸಿದಾಗ, `worker(2)` ದೋಷವನ್ನು ಎತ್ತುತ್ತದೆ ಎಂದು ನೀವು ನೋಡುತ್ತೀರಿ. `TaskGroup` ಇದನ್ನು ಹಿಡಿಯುತ್ತದೆ, ಇತರ ಚಾಲನೆಯಲ್ಲಿರುವ ಕಾರ್ಯಗಳನ್ನು ರದ್ದುಗೊಳಿಸುತ್ತದೆ (ಇಷ್ಟ `worker(3)`), ತದನಂತರ `ValueError` ಅನ್ನು ಒಳಗೊಂಡಿರುವ `ExceptionGroup` ಅನ್ನು ಎತ್ತುತ್ತದೆ. ವಿಶ್ವಾಸಾರ್ಹ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ಈ ಮಾದರಿಯು ನಂಬಲಾಗದಷ್ಟು ದೃಢವಾಗಿದೆ.

ಕ್ಲಾಸಿಕ್ ವರ್ಕ್‌ಹಾರ್ಸ್: `asyncio.gather()`

`TaskGroup` ಮೊದಲು, `asyncio.gather()` ಅನೇಕ ನಿರೀಕ್ಷೆಗಳನ್ನು ಸಮಕಾಲೀನವಾಗಿ ರನ್ ಮಾಡಲು ಮತ್ತು ಅವೆಲ್ಲವೂ ಮುಗಿಯಲು ಕಾಯಲು ಸಾಮಾನ್ಯ ಮಾರ್ಗವಾಗಿತ್ತು.

gather() ಕೊರೂಟಿನ್‌ಗಳು ಅಥವಾ ಕಾರ್ಯಗಳ ಅನುಕ್ರಮವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಅವೆಲ್ಲವನ್ನೂ ಚಲಾಯಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳ ಫಲಿತಾಂಶಗಳ ಪಟ್ಟಿಯನ್ನು ಇನ್‌ಪುಟ್‌ಗಳಂತೆಯೇ ಅದೇ ಕ್ರಮದಲ್ಲಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಇದು ಸಾಮಾನ್ಯ ಸಂದರ್ಭಕ್ಕಾಗಿ "ಇವೆಲ್ಲವನ್ನೂ ಚಲಾಯಿಸಿ ಮತ್ತು ನನಗೆ ಎಲ್ಲಾ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡಿ" ಎಂಬ ಉನ್ನತ ಮಟ್ಟದ, ಅನುಕೂಲಕರ ಕಾರ್ಯವಾಗಿದೆ.

            import asyncio

async def fetch_data(source, delay):
    print(f"Fetching from {source}...")
    await asyncio.sleep(delay)
    return {"source": source, "data": f"some data from {source}"}

async def main():
    # gather can take coroutines directly
    results = await asyncio.gather(
        fetch_data("API", 2),
        fetch_data("Database", 3),
        fetch_data("Cache", 1)
    )
    print(results)

asyncio.run(main())
            

              
                Copy
              
            
          

`gather()` ಜೊತೆಗೆ ದೋಷ ನಿರ್ವಹಣೆ: ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ನೀವು `gather()`ಗೆ ರವಾನಿಸಿದ ಯಾವುದೇ ನಿರೀಕ್ಷೆಗಳು ವಿನಾಯಿತಿಯನ್ನು ಎತ್ತಿದರೆ, `gather()` ತಕ್ಷಣವೇ ಆ ವಿನಾಯಿತಿಯನ್ನು ಪ್ರಸಾರ ಮಾಡುತ್ತದೆ ಮತ್ತು ಇತರ ಚಾಲನೆಯಲ್ಲಿರುವ ಕಾರ್ಯಗಳನ್ನು ರದ್ದುಗೊಳಿಸಲಾಗುತ್ತದೆ. ನೀವು `return_exceptions=True` ನೊಂದಿಗೆ ಈ ನಡವಳಿಕೆಯನ್ನು ಬದಲಾಯಿಸಬಹುದು. ಈ ಮೋಡ್‌ನಲ್ಲಿ, ವಿನಾಯಿತಿಯನ್ನು ಎತ್ತುವ ಬದಲು, ಅದನ್ನು ಅನುಗುಣವಾದ ಸ್ಥಾನದಲ್ಲಿ ಫಲಿತಾಂಶಗಳ ಪಟ್ಟಿಯಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ.

            # ... inside main()
    results = await asyncio.gather(
        fetch_data("API", 2),
        asyncio.create_task(worker(1)), # This will raise a ValueError
        fetch_data("Cache", 1),
        return_exceptions=True
    )
    # results will contain a mix of successful results and exception objects
    print(results)
            

              
                Copy
              
            
          

ಸಣ್ಣ-ಧಾನ್ಯ ನಿಯಂತ್ರಣ: `asyncio.wait()`

asyncio.wait() ಎನ್ನುವುದು ಕಾರ್ಯಗಳ ಗುಂಪಿನ ಮೇಲೆ ಹೆಚ್ಚು ವಿವರವಾದ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುವ ಒಂದು ಕಡಿಮೆ-ಮಟ್ಟದ ಕಾರ್ಯವಾಗಿದೆ. `gather()` ನಿಂದ ಭಿನ್ನವಾಗಿ, ಇದು ನೇರವಾಗಿ ಫಲಿತಾಂಶಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ಇದು ಎರಡು ಕಾರ್ಯಗಳ ಸೆಟ್‌ಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ: `done` ಮತ್ತು `pending`.

ಇದರ ಅತ್ಯಂತ ಶಕ್ತಿಯುತವಾದ ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ `return_when` ಪ್ಯಾರಾಮೀಟರ್, ಇದು ಹೀಗಿರಬಹುದು:

• asyncio.ALL_COMPLETED (ಡೀಫಾಲ್ಟ್): ಎಲ್ಲಾ ಕಾರ್ಯಗಳು ಮುಗಿದಾಗ ಹಿಂತಿರುಗುತ್ತದೆ.
• asyncio.FIRST_COMPLETED: ಕನಿಷ್ಠ ಒಂದು ಕಾರ್ಯವು ಮುಗಿದ ಕೂಡಲೇ ಹಿಂತಿರುಗುತ್ತದೆ.
• asyncio.FIRST_EXCEPTION: ಒಂದು ಕಾರ್ಯವು ವಿನಾಯಿತಿಯನ್ನು ಎತ್ತಿದಾಗ ಹಿಂತಿರುಗುತ್ತದೆ. ಯಾವುದೇ ಕಾರ್ಯವು ವಿನಾಯಿತಿಯನ್ನು ಎತ್ತದಿದ್ದರೆ, ಇದು `ALL_COMPLETED` ಗೆ ಸಮನಾಗಿರುತ್ತದೆ.

ಬಹು ಹೆಚ್ಚುವರಿ ಡೇಟಾ ಮೂಲಗಳನ್ನು ಪ್ರಶ್ನಿಸುವ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯಿಸುವ ಮೊದಲನೆಯದನ್ನು ಬಳಸುವಂತಹ ಸನ್ನಿವೇಶಗಳಿಗೆ ಇದು ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾಗಿದೆ:

            import asyncio

async def query_source(name, delay):
    await asyncio.sleep(delay)
    return f"Result from {name}"

async def main():
    tasks = [
        asyncio.create_task(query_source("Fast Mirror", 0.5)),
        asyncio.create_task(query_source("Slow Main DB", 2.0)),
        asyncio.create_task(query_source("Geographic Replica", 0.8))
    ]

    done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)

    # Get the result from the completed task
    first_result = done.pop().result()
    print(f"Got first result: {first_result}")

    # We now have pending tasks that are still running. It's crucial to clean them up!
    print(f"Cancelling {len(pending)} pending tasks...")
    for task in pending:
        task.cancel()

    # Await the cancelled tasks to allow them to process the cancellation
    await asyncio.gather(*pending, return_exceptions=True)
    print("Cleanup complete.")

asyncio.run(main())
            

              
                Copy
              
            
          

TaskGroup vs. gather() vs. wait(): ಯಾವುದನ್ನು ಯಾವಾಗ ಬಳಸುವುದು?

• `asyncio.TaskGroup` ಅನ್ನು ಬಳಸಿ (Python 3.11+) ನಿಮ್ಮ ಡೀಫಾಲ್ಟ್ ಆಯ್ಕೆಯಾಗಿ. ಇದರ ರಚನಾತ್ಮಕ ಸಮಕಾಲೀನ ಮಾದರಿಯು ಸುರಕ್ಷಿತವಾಗಿದೆ, ಸ್ವಚ್ಛವಾಗಿದೆ ಮತ್ತು ಒಂದೇ ತಾರ್ಕಿಕ ಕಾರ್ಯಾಚರಣೆಗೆ ಸೇರಿದ ಕಾರ್ಯಗಳ ಗುಂಪನ್ನು ನಿರ್ವಹಿಸಲು ಕಡಿಮೆ ದೋಷಪೂರಿತವಾಗಿದೆ.
• `asyncio.gather()` ಅನ್ನು ಬಳಸಿ ನೀವು ಸ್ವತಂತ್ರ ಕಾರ್ಯಗಳ ಗುಂಪನ್ನು ರನ್ ಮಾಡಬೇಕಾದಾಗ ಮತ್ತು ಅವುಗಳ ಫಲಿತಾಂಶಗಳ ಪಟ್ಟಿಯನ್ನು ಬಯಸಿದಾಗ. ಇದು ಇನ್ನೂ ತುಂಬಾ ಉಪಯುಕ್ತವಾಗಿದೆ ಮತ್ತು ಸರಳ ಸಂದರ್ಭಗಳಲ್ಲಿ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಂಕ್ಷಿಪ್ತವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ Python ಆವೃತ್ತಿಗಳಲ್ಲಿ 3.11 ಮೊದಲು.
• `asyncio.wait()` ಅನ್ನು ಬಳಸಿ ನೀವು ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯ ಪರಿಸ್ಥಿತಿಗಳ ಮೇಲೆ ಉತ್ತಮ-ಧಾನ್ಯ ನಿಯಂತ್ರಣದ ಅಗತ್ಯವಿರುವ ಸುಧಾರಿತ ಸನ್ನಿವೇಶಗಳಿಗಾಗಿ (ಉದಾಹರಣೆಗೆ, ಮೊದಲ ಫಲಿತಾಂಶಕ್ಕಾಗಿ ಕಾಯುವುದು) ಮತ್ತು ಉಳಿದಿರುವ ಬಾಕಿ ಇರುವ ಕಾರ್ಯಗಳನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸಲು ಸಿದ್ಧರಾಗಿರಿ.

ಕಾರ್ಯ ಜೀವನಚಕ್ರ ಮತ್ತು ನಿರ್ವಹಣೆ

ಒಮ್ಮೆ ಕಾರ್ಯವನ್ನು ರಚಿಸಿದ ನಂತರ, ನೀವು `Task` ವಸ್ತುವಿನಲ್ಲಿನ ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅದರೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಬಹುದು.

ಕಾರ್ಯ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ

• task.done(): ಕಾರ್ಯವು ಪೂರ್ಣಗೊಂಡಿದ್ದರೆ (ಯಶಸ್ವಿಯಾಗಿ, ವಿನಾಯಿತಿಯೊಂದಿಗೆ ಅಥವಾ ರದ್ದತಿಯ ಮೂಲಕ) `True` ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• task.cancelled(): ಕಾರ್ಯವನ್ನು ರದ್ದುಗೊಳಿಸಿದರೆ `True` ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• task.exception(): ಕಾರ್ಯವು ವಿನಾಯಿತಿಯನ್ನು ಎತ್ತಿದರೆ, ಇದು ವಿನಾಯಿತಿ ವಸ್ತುವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಅದು `None` ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಕಾರ್ಯವು `done()` ಆದ ನಂತರ ಮಾತ್ರ ನೀವು ಇದನ್ನು ಕರೆಯಬಹುದು.

ಫಲಿತಾಂಶಗಳನ್ನು ಮರುಪಡೆಯಲಾಗುತ್ತಿದೆ

ಕಾರ್ಯದ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯುವ ಮುಖ್ಯ ಮಾರ್ಗವೆಂದರೆ ಸರಳವಾಗಿ `await task`. ಕಾರ್ಯವು ಯಶಸ್ವಿಯಾಗಿ ಮುಗಿದಿದ್ದರೆ, ಇದು ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಇದು ವಿನಾಯಿತಿಯನ್ನು ಎತ್ತಿದರೆ, `await task` ಆ ವಿನಾಯಿತಿಯನ್ನು ಮತ್ತೆ ಎತ್ತುತ್ತದೆ. ಇದನ್ನು ರದ್ದುಗೊಳಿಸಿದರೆ, `await task` `CancelledError` ಅನ್ನು ಎತ್ತುತ್ತದೆ.

ಪರ್ಯಾಯವಾಗಿ, ಕಾರ್ಯವು `done()` ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದ್ದರೆ, ನೀವು `task.result()` ಅನ್ನು ಕರೆಯಬಹುದು. ಇದು ಮೌಲ್ಯಗಳನ್ನು ಹಿಂದಿರುಗಿಸುವ ಅಥವಾ ವಿನಾಯಿತಿಗಳನ್ನು ಎತ್ತುವ ದೃಷ್ಟಿಯಿಂದ `await task` ನಂತೆಯೇ ವರ್ತಿಸುತ್ತದೆ.

ರದ್ದತಿ ಕಲೆ

ದೀರ್ಘಕಾಲ ಚಾಲನೆಯಲ್ಲಿರುವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ದಯೆಯಿಂದ ರದ್ದುಗೊಳಿಸಲು ಸಾಧ್ಯವಾಗುವುದು ದೃಢವಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಸಮಯ ಮೀರುವುದು, ಬಳಕೆದಾರರ ವಿನಂತಿ ಅಥವಾ ಸಿಸ್ಟಮ್‌ನ ಇನ್ನೆಲ್ಲೋ ದೋಷದಿಂದಾಗಿ ನೀವು ಕಾರ್ಯವನ್ನು ರದ್ದುಗೊಳಿಸಬೇಕಾಗಬಹುದು.

ನೀವು ಅದರ task.cancel() ವಿಧಾನವನ್ನು ಕರೆದು ಕಾರ್ಯವನ್ನು ರದ್ದುಗೊಳಿಸುತ್ತೀರಿ. ಆದಾಗ್ಯೂ, ಇದು ತಕ್ಷಣವೇ ಕಾರ್ಯವನ್ನು ನಿಲ್ಲಿಸುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ಇದು ಮುಂದಿನ await ಪಾಯಿಂಟ್‌ನಲ್ಲಿ ಕೊರೂಟಿನ್ ಒಳಗೆ ಎಸೆಯಲು `CancelledError` ವಿನಾಯಿತಿಯನ್ನು ನಿಗದಿಪಡಿಸುತ್ತದೆ. ಇದು ನಿರ್ಣಾಯಕ ವಿವರವಾಗಿದೆ. ಇದು ನಿರ್ಗಮಿಸುವ ಮೊದಲು ಸ್ವಚ್ಛಗೊಳಿಸಲು ಕೊರೂಟಿನ್‌ಗೆ ಅವಕಾಶವನ್ನು ನೀಡುತ್ತದೆ.

ಒಳ್ಳೆಯ ನಡವಳಿಕೆಯ ಕೊರೂಟಿನ್ ಈ `CancelledError` ಅನ್ನು ದಯೆಯಿಂದ ನಿರ್ವಹಿಸಬೇಕು, ಸಾಮಾನ್ಯವಾಗಿ ಫೈಲ್ ಹ್ಯಾಂಡಲ್‌ಗಳು ಅಥವಾ ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕಗಳಂತಹ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಮುಚ್ಚಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು `try...finally` ಬ್ಲಾಕ್ ಅನ್ನು ಬಳಸುವುದು.

            import asyncio

async def resource_intensive_task():
    print("Acquiring resource (e.g., opening a connection)...")
    try:
        for i in range(10):
            print(f"Working... step {i+1}")
            await asyncio.sleep(1) # This is an await point where CancelledError can be injected
    except asyncio.CancelledError:
        print("Task was cancelled! Cleaning up...")
        raise # It's good practice to re-raise CancelledError
    finally:
        print("Releasing resource (e.g., closing connection). This always runs.")

async def main():
    task = asyncio.create_task(resource_intensive_task())

    # Let it run for a bit
    await asyncio.sleep(2.5)

    print("Main decides to cancel the task.")
    task.cancel()

    try:
        await task
    except asyncio.CancelledError:
        print("Main has confirmed the task was cancelled.")

asyncio.run(main())
            

              
                Copy
              
            
          

`finally` ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಖಾತರಿಪಡಿಸಲಾಗಿದೆ, ಇದು ಸ್ವಚ್ಛಗೊಳಿಸುವ ತರ್ಕಕ್ಕಾಗಿ ಪರಿಪೂರ್ಣ ಸ್ಥಳವಾಗಿದೆ.

`asyncio.timeout()` ಮತ್ತು `asyncio.wait_for()` ನೊಂದಿಗೆ ಸಮಯ ಮಿತಿಗಳನ್ನು ಸೇರಿಸುವುದು

ಹಸ್ತಚಾಲಿತವಾಗಿ ಸ್ಲೀಪಿಂಗ್ ಮತ್ತು ರದ್ದುಗೊಳಿಸುವುದು ಬೇಸರದ ಸಂಗತಿಯಾಗಿದೆ. `asyncio` ಈ ಸಾಮಾನ್ಯ ಮಾದರಿಗಾಗಿ ಸಹಾಯಕರನ್ನು ಒದಗಿಸುತ್ತದೆ.

Python 3.11+ ನಲ್ಲಿ, `asyncio.timeout()` ಸಂದರ್ಭ ನಿರ್ವಾಹಕವು ಆದ್ಯತೆಯ ಮಾರ್ಗವಾಗಿದೆ:

            async def long_running_operation():
    await asyncio.sleep(10)
    print("Operation finished")

async def main():
    try:
        async with asyncio.timeout(2): # Set a 2-second timeout
            await long_running_operation()
    except TimeoutError:
        print("The operation timed out!")

asyncio.run(main())
            

              
                Copy
              
            
          

ಹಳೆಯ Python ಆವೃತ್ತಿಗಳಿಗೆ, ನೀವು `asyncio.wait_for()` ಅನ್ನು ಬಳಸಬಹುದು. ಇದು ಅದೇ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಆದರೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯ ಕರೆಗೆ ಸುತ್ತುತ್ತದೆ:

            async def main_legacy():
    try:
        await asyncio.wait_for(long_running_operation(), timeout=2)
    except asyncio.TimeoutError:
        print("The operation timed out!")

asyncio.run(main_legacy())
            

              
                Copy
              
            
          

ಸಮಯ ಮಿತಿಯನ್ನು ತಲುಪಿದಾಗ ಎರಡೂ ಪರಿಕರಗಳು ಆಂತರಿಕ ಕಾರ್ಯವನ್ನು ರದ್ದುಗೊಳಿಸುವ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, `TimeoutError` ಅನ್ನು ಎತ್ತುತ್ತವೆ (ಇದು `CancelledError`ನ ಉಪವರ್ಗವಾಗಿದೆ).

ಸಾಮಾನ್ಯ ಅಪಾಯಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಕಾರ್ಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಶಕ್ತಿಯುತವಾಗಿದೆ, ಆದರೆ ತಪ್ಪಿಸಬೇಕಾದ ಕೆಲವು ಸಾಮಾನ್ಯ ತೊಂದರೆಗಳಿವೆ.

• ಅಪಾಯ: "ಫೈರ್ ಅಂಡ್ ಫರ್ಗೆಟ್" ತಪ್ಪು. `create_task` ನೊಂದಿಗೆ ಕಾರ್ಯವನ್ನು ರಚಿಸುವುದು ಮತ್ತು ನಂತರ ಅದನ್ನು ಎಂದಿಗೂ ನಿರೀಕ್ಷಿಸದಿರುವುದು (ಅಥವಾ `TaskGroup` ನಂತಹ ವ್ಯವಸ್ಥಾಪಕ) ಅಪಾಯಕಾರಿ. ಆ ಕಾರ್ಯವು ವಿನಾಯಿತಿಯನ್ನು ಎತ್ತಿದರೆ, ವಿನಾಯಿತಿಯನ್ನು ಮೌನವಾಗಿ ಕಳೆದುಕೊಳ್ಳಬಹುದು ಮತ್ತು ಕಾರ್ಯವು ತನ್ನ ಕೆಲಸವನ್ನು ಪೂರ್ಣಗೊಳಿಸುವ ಮೊದಲು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ನಿರ್ಗಮಿಸಬಹುದು. ಅದರ ಫಲಿತಾಂಶವನ್ನು ನಿರೀಕ್ಷಿಸಲು ಜವಾಬ್ದಾರರಾಗಿರುವ ಪ್ರತಿಯೊಂದು ಕಾರ್ಯಕ್ಕೂ ಯಾವಾಗಲೂ ಸ್ಪಷ್ಟ ಮಾಲೀಕರು ಇರಬೇಕು.
• ಅಪಾಯ: `asyncio.run()` ಅನ್ನು `create_task()` ನೊಂದಿಗೆ ಗೊಂದಲಗೊಳಿಸುವುದು. `asyncio.run(my_coro())` ಎನ್ನುವುದು `asyncio` ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಮುಖ್ಯ ಪ್ರವೇಶ ಬಿಂದುವಾಗಿದೆ. ಇದು ಹೊಸ ಈವೆಂಟ್ ಲೂಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ನೀಡಲಾದ ಕೊರೂಟಿನ್ ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ಅದನ್ನು ಚಲಾಯಿಸುತ್ತದೆ. `asyncio.create_task(my_coro())` ಸಮಕಾಲೀನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿಗದಿಪಡಿಸಲು ಈಗಾಗಲೇ ಚಾಲನೆಯಲ್ಲಿರುವ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯದ ಒಳಗೆ ಬಳಸಲಾಗುತ್ತದೆ.
• ಉತ್ತಮ ಅಭ್ಯಾಸ: ಆಧುನಿಕ Python ಗಾಗಿ `TaskGroup` ಅನ್ನು ಬಳಸಿ. ಇದರ ವಿನ್ಯಾಸವು ಮರೆತುಹೋದ ಕಾರ್ಯಗಳು ಮತ್ತು ನಿರ್ವಹಿಸದ ವಿನಾಯಿತಿಗಳಂತಹ ಅನೇಕ ಸಾಮಾನ್ಯ ದೋಷಗಳನ್ನು ತಡೆಯುತ್ತದೆ. ನೀವು Python 3.11 ಅಥವಾ ನಂತರದ ಆವೃತ್ತಿಯಲ್ಲಿದ್ದರೆ, ಅದನ್ನು ನಿಮ್ಮ ಡೀಫಾಲ್ಟ್ ಆಯ್ಕೆಯಾಗಿ ಮಾಡಿ.
• ಉತ್ತಮ ಅಭ್ಯಾಸ: ನಿಮ್ಮ ಕಾರ್ಯಗಳಿಗೆ ಹೆಸರಿಸಿ. ಕಾರ್ಯವನ್ನು ರಚಿಸುವಾಗ, `name` ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಬಳಸಿ: `asyncio.create_task(my_coro(), name='DataProcessor-123')`. ಇದು ಡೀಬಗ್ ಮಾಡಲು ಅಮೂಲ್ಯವಾಗಿದೆ. ಎಲ್ಲಾ ಚಾಲನೆಯಲ್ಲಿರುವ ಕಾರ್ಯಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುವಾಗ, ಅರ್ಥಪೂರ್ಣ ಹೆಸರುಗಳನ್ನು ಹೊಂದಿರುವುದು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಏನು ಮಾಡುತ್ತಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
• ಉತ್ತಮ ಅಭ್ಯಾಸ: ದಯೆಯಿಂದ ಸ್ಥಗಿತಗೊಳಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಸ್ಥಗಿತಗೊಳ್ಳಬೇಕಾದಾಗ, ಚಾಲನೆಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಹಿನ್ನೆಲೆ ಕಾರ್ಯಗಳನ್ನು ರದ್ದುಗೊಳಿಸಲು ಮತ್ತು ಅವುಗಳನ್ನು ಸರಿಯಾಗಿ ಸ್ವಚ್ಛಗೊಳಿಸಲು ಕಾಯಲು ನಿಮಗೆ ಕಾರ್ಯವಿಧಾನವಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ಸುಧಾರಿತ ಪರಿಕಲ್ಪನೆಗಳು: ಆಚೆಗೆ ಒಂದು ನೋಟ

ಡೀಬಗ್ ಮಾಡುವಿಕೆ ಮತ್ತು ಆತ್ಮಾವಲೋಕನಕ್ಕಾಗಿ, `asyncio` ಕೆಲವು ಉಪಯುಕ್ತ ಕಾರ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ:

• asyncio.current_task(): ಪ್ರಸ್ತುತ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತಿರುವ ಕೋಡ್‌ಗಾಗಿ `Task` ವಸ್ತುವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• asyncio.all_tasks(): ಪ್ರಸ್ತುತ ಈವೆಂಟ್ ಲೂಪ್‌ನಿಂದ ನಿರ್ವಹಿಸಲ್ಪಡುವ ಎಲ್ಲಾ `Task` ವಸ್ತುಗಳ ಸೆಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಇದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವುದನ್ನು ನೋಡಲು ಡೀಬಗ್ ಮಾಡಲು ಉತ್ತಮವಾಗಿದೆ.

ನೀವು `task.add_done_callback()` ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕಾರ್ಯಗಳಿಗೆ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯ ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳನ್ನು ಸಹ ಲಗತ್ತಿಸಬಹುದು. ಇದು ಉಪಯುಕ್ತವಾಗಿದ್ದರೂ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ, ಕಾಲ್‌ಬ್ಯಾಕ್-ಶೈಲಿಯ ಕೋಡ್ ರಚನೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಓದುವಿಕೆ ಮತ್ತು ನಿರ್ವಹಣಾ ಸಾಮರ್ಥ್ಯಕ್ಕಾಗಿ `await`, `TaskGroup`, ಅಥವಾ `gather` ಅನ್ನು ಬಳಸುವ ಆಧುನಿಕ ವಿಧಾನಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಆದ್ಯತೆ ನೀಡಲಾಗುತ್ತದೆ.

ತೀರ್ಮಾನ

`asyncio.Task` ಆಧುನಿಕ Python ನಲ್ಲಿ ಸಮಕಾಲೀನತೆಯ ಎಂಜಿನ್ ಆಗಿದೆ. ಕಾರ್ಯಗಳ ಜೀವನಚಕ್ರವನ್ನು ಹೇಗೆ ರಚಿಸುವುದು, ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ದಯೆಯಿಂದ ನಿರ್ವಹಿಸುವುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನಿಮ್ಮ I/O-ಬೌಂಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿಧಾನ, ಅನುಕ್ರಮ ಪ್ರಕ್ರಿಯೆಗಳಿಂದ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ, ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ವ್ಯವಸ್ಥೆಗಳಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು.

ನಾವು `create_task()` ನೊಂದಿಗೆ ಕೊರೂಟಿನ್ ಅನ್ನು ನಿಗದಿಪಡಿಸುವ ಮೂಲ ಪರಿಕಲ್ಪನೆಯಿಂದ ಹಿಡಿದು `TaskGroup`, `gather()` ಮತ್ತು `wait()` ನೊಂದಿಗೆ ಸಂಕೀರ್ಣ ಕೆಲಸದ ಹರಿವುಗಳನ್ನು ಸಂಘಟಿಸುವವರೆಗಿನ ಪ್ರಯಾಣವನ್ನು ಒಳಗೊಂಡಿದೆ. ದೃಢವಾದ ದೋಷ ನಿರ್ವಹಣೆ, ರದ್ದತಿ ಮತ್ತು ಸಮಯ ಮೀರುವುದರ ನಿರ್ಣಾಯಕ ಪ್ರಾಮುಖ್ಯತೆಯನ್ನು ನಾವು ಅನ್ವೇಷಿಸಿದ್ದೇವೆ. ಸ್ಥಿತಿಸ್ಥಾಪಕ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಇವುಗಳು ಅಗತ್ಯ.

ಅಸಮಕಾಲಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಜಗತ್ತು ವಿಸ್ತಾರವಾಗಿದೆ, ಆದರೆ ಕಾರ್ಯಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು ನೀವು ತೆಗೆದುಕೊಳ್ಳಬಹುದಾದ ಅತ್ಯಂತ ಮಹತ್ವದ ಹೆಜ್ಜೆಯಾಗಿದೆ. ಪ್ರಯೋಗವನ್ನು ಪ್ರಾರಂಭಿಸಿ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಅನುಕ್ರಮ, I/O-ಬೌಂಡ್ ಭಾಗವನ್ನು ಸಮಕಾಲೀನ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲು ಪರಿವರ್ತಿಸಿ ಮತ್ತು ನಿಮಗಾಗಿ ಕಾರ್ಯಕ್ಷಮತೆ ಹೆಚ್ಚಳವನ್ನು ನೋಡಿ. ಸಮಕಾಲೀನತೆಯ ಶಕ್ತಿಯನ್ನು ಸ್ವೀಕರಿಸಿ, ಮತ್ತು ನೀವು ಮುಂದಿನ ಪೀಳಿಗೆಯ ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆಯ Python ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಉತ್ತಮವಾಗಿ ಸಜ್ಜುಗೊಳ್ಳುವಿರಿ.